#include "cuda_malloc.cuh"

#define MIN(a, b) (((a) < (b)) ? (a) : (b))

__device__ size_t cuda_strlen(const char* str) {
    const char* start = str;  // 记录起始位置
    while (*str) str++;       // 遍历至字符串结尾（遇到 '\0' 停止）
    return str - start;       // 指针相减得到长度
}
class String {
private:
    char* data;     // 存储字符串数据
    size_t length;  // 当前字符串长度（不含结尾空字符）

    // 私有辅助函数：分配内存并复制内容
    __device__ void copy_from(const char* str, size_t len) {
        if (len == 0) {
            data = nullptr;
            length = 0;
            return;
        }

        data = static_cast<char*>(
                cuda_kernel_malloc(global_memory_pool, PER_THREAD_SIZE, len + 1));  // +1 用于结尾空字符
        if (data) {
            memcpy(data, str, len);
            data[len] = '\0';
            length = len;
        } else {
            length = 0;
        }
    }

public:
    // 默认构造函数（创建空字符串）
    __device__ String() : data(nullptr), length(0) {}

    // 从C字符串构造
    __device__ String(const char* str) : data(nullptr), length(0) {
        if (str) {
            size_t len = strlen(str);
            copy_from(str, len);
        }
    }

    // 拷贝构造函数
    __device__ String(const String& other) : data(nullptr), length(0) {
        if (other.data) {
            copy_from(other.data, other.length);
        }
    }

    // 拷贝赋值运算符
    __device__ String& operator=(const String& other) {
        if (this != &other) {                                                       // 防止自赋值
            if (data) cuda_kernel_free(global_memory_pool, PER_THREAD_SIZE, data);  // 释放现有资源

            if (other.data) {
                copy_from(other.data, other.length);
            } else {
                data = nullptr;
                length = 0;
            }
        }
        return *this;
    }

    // 析构函数
    __device__ ~String() {
        if (data) cuda_kernel_free(global_memory_pool, PER_THREAD_SIZE, data);
    }

    // 追加 C 风格字符串
    __device__ void append(const char* str) {
        if (!str || *str == '\0') return;

        size_t str_len = cuda_strlen(str);
        size_t new_length = length + str_len;

        char* new_data = static_cast<char*>(cuda_kernel_malloc(global_memory_pool, PER_THREAD_SIZE, new_length + 1));
        if (!new_data) return;

        // 复制原内容
        if (data) {
            memcpy(new_data, data, length);
            cuda_kernel_free(global_memory_pool, PER_THREAD_SIZE, data);
        }

        // 追加新内容
        memcpy(new_data + length, str, str_len);
        new_data[new_length] = '\0';

        data = new_data;
        length = new_length;
    }

    // 追加单个字符
    __device__ void append(char c) {
        size_t new_length = length + 1;
        char* new_data = static_cast<char*>(cuda_kernel_malloc(global_memory_pool, PER_THREAD_SIZE, new_length + 1));
        if (!new_data) return;

        // 复制原内容
        if (data) {
            memcpy(new_data, data, length);
            cuda_kernel_free(global_memory_pool, PER_THREAD_SIZE, data);
        }

        // 追加新字符
        new_data[length] = c;
        new_data[new_length] = '\0';

        data = new_data;
        length = new_length;
    }

    // 获取 C 风格字符串（只读）
    __device__ const char* c_str() const {
        return data ? data : "";
    }

    // 获取长度
    __device__ size_t size() const {
        return length;
    }
};

__device__ String convert_float_to_string(float value, int decimal_places = 4) {
    const char digit_chars[] = "0123456789";
    String result;

    if (isnan(value)) {
        result.append("nan");
        return result;
    }
    if (isinf(value)) {
        result.append("inf");
        return result;
    }

    if (value < 0) {
        result.append('-');
        value = -value;
    } else {
        result.append(' ');
    }

    int integer_value = (int)value;
    float fractional_value = value - integer_value;

    if (integer_value == 0) {
        result.append('0');
    } else {
        char integer_buffer[16];
        int digit_counter = 0;

        do {
            integer_buffer[digit_counter++] = digit_chars[integer_value % 10];
            integer_value /= 10;
        } while (integer_value > 0 && digit_counter < 15);

        while (--digit_counter >= 0) {
            result.append(integer_buffer[digit_counter]);
        }
    }

    result.append('.');
    for (int place = 0; place < decimal_places; place++) {
        fractional_value *= 10;
        int digit = (int)fractional_value;
        result.append(digit_chars[digit]);
        fractional_value -= digit;
    }

    return result;
}

__device__ String size_t_to_string(size_t value) {
    String result;

    // 处理 value=0 的特殊情况
    if (value == 0) {
        result.append('0');
        return result;
    }

    char temp[20];  // 栈空间临时数组（4096位 size_t 最大20位）
    size_t index = 0;

    // 逆序分解数字（低位→高位）
    while (value != 0) {
        temp[index++] = '0' + (value % 10);  // 取末位转字符
        value /= 10;
    }

    // 正序填充到 FixedString（高位→低位）
    for (size_t i = index; i > 0;) {
        result.append(temp[--i]);  // 从末尾向前取字符
    }
    return result;
}

template <typename T, size_t N = 16>
class FixedVector {
private:
    T data[N];
    size_t current_size = 0;  // 当前实际元素数量

public:
    // 默认构造函数
    __device__ FixedVector() : current_size(0) {}

    // 参数包构造函数
    template <typename... Args>
    __device__ FixedVector(Args... args) : current_size(0) {
        init(0, args...);
    }

    // 辅助函数：递归初始化
    __device__ void init(size_t index) {}  // 终止递归

    template <typename Arg, typename... Args>
    __device__ void init(size_t index, Arg a, Args... args) {
        data[index] = a;
        current_size++;  // 更新元素计数
        init(index + 1, args...);
    }

    // push_back：添加元素到末尾
    __device__ void push_back(const T& value) {
        data[current_size++] = value;
    }

    // 获取有效元素数量
    __device__ size_t size() const {
        return current_size;
    }

    // 下标访问（仅允许访问有效范围内的元素）
    __device__ T& operator[](size_t i) {
        return data[i];
    }

    __device__ const T& operator[](size_t i) const {
        return data[i];
    }
};

class Range {
public:
    size_t begin;
    size_t end;
    Range() = default;
    __device__ Range(size_t _begin, size_t _end) : begin(_begin), end(_end) {}
};